package org.example.clouddemo.recommend.service.common.impl;

import lombok.RequiredArgsConstructor;
import org.example.clouddemo.bean.common.entity.Order;
import org.example.clouddemo.bean.common.entity.Product;
import org.example.clouddemo.bean.common.entity.User;
import org.example.clouddemo.recommend.feign.OrderFeignClient;
import org.example.clouddemo.recommend.feign.ProductFeignClient;
import org.example.clouddemo.recommend.feign.UserFeignClient;
import org.example.clouddemo.recommend.service.common.RecommendService;
import org.example.common.response.ApiResult;
import org.springframework.stereotype.Service;

import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.Objects;
import java.util.Set;
import java.util.stream.Collectors;


/**
* 推荐表 服务实现类
*/
@RequiredArgsConstructor
@Service // 业务逻辑层
public class RecommendServiceImpl implements RecommendService {

    private final ProductFeignClient productFeignClient;

    private final OrderFeignClient orderFeignClient;

    private final UserFeignClient userFeignClient;


    /**
     * 根据ID查找商品（辅助方法）
     */
    private Product findProductById(List<Product> products, Long id) {
        return products.stream()
                .filter(p -> p.getId().equals(id))
                .findFirst()
                .orElse(null);
    }

    public List<Product> recommendProductListByUserId(Long userId) {
        // 1、查询用户id
        User user = new User();
        user.setId(userId);
        ApiResult<User> userApiResult = userFeignClient.queryOne(userId);
        // 用户不存在
        if(!Objects.equals(userId,userApiResult.getData().getId())){
            return new ArrayList<>();
        }
        // 2、通过用户id查询对应的订单列表
        ApiResult<List<Order>> apiOrderResult = orderFeignClient.getByUserId(userId);
        List<Order> orders = apiOrderResult.getData();
        // 3、查询最贵的3个产品
        ApiResult<List<Product>> apiProductResult = productFeignClient.selectOrderByPriceDesc();
        List<Product> products = apiProductResult.getData();


        // 获取优先选择的订单商品（最多3个，去重）
        Set<Long> selectedIds = new HashSet<>();
        List<Product> result = orders.stream()
                .limit(3)
                .map(Order::getProductId)
                .distinct()
                .map(id -> findProductById(products, id))
                .filter(Objects::nonNull)
                .peek(p -> selectedIds.add(p.getId()))
                .collect(Collectors.toList());

        // 补足逻辑
        if (result.size() < 3 && !products.isEmpty()) {
            // 获取主补足商品（商品列表的第一个）
            Product primaryReplacement = products.get(0);
            if (!selectedIds.contains(primaryReplacement.getId())) {
                result.add(primaryReplacement);
                selectedIds.add(primaryReplacement.getId());
            }

            // 如果还需要更多商品
            int needed = 3 - result.size();
            if (needed > 0) {
                products.stream()
                        .filter(p -> !selectedIds.contains(p.getId()))
                        .limit(needed)
                        .forEach(result::add);
            }
        }

        // 限制最多3个
        return result.stream().limit(3).collect(Collectors.toList());
    }
//    @Override
//    public IPage<Product> recommendProductList(Page<Product> page) {
//        // 获取当前页码和每页大小
//        long current = page.getCurrent();
//        long size = page.getSize();
//        // 计算起始记录位置
//        long startIndex = (current - 1) * size;
//        ApiResult<List<Order>> orderListResult = orderFeignClient.getByUserId();
//        if (!orderListResult.isSuccess()) {
//            // 创建一个空的Product对象作为查询条件
//            Product queryParam = new Product();
//            // 设置enableFlag=1，只查询启用的产品
//            queryParam.setEnableFlag(true);
//
//            // 调用远程服务获取产品列表
//            ApiResult<IPage<Product>> result = productFeignClient.list((int)current, (int)size, queryParam);
//
//            // 如果需要按价格排序，获取结果后在本地排序
//            if (result.isSuccess()) {
//                List<Product> products = result.getData().getRecords();
//                products.sort(Comparator.comparingInt(Product::getPrice).reversed());
//                result.getData().setRecords(products);
//                return result.getData();
//            }
//            return new Page<>();
//        }
//
//        List<Order> orderList = orderListResult.getData();
//        List<Long> productIds = orderList.stream()
//                .map(Order::getProductId)  // 提取每个订单的productId
//                .collect(Collectors.toList());  // 收集为列表
//
//        // 调用远程服务获取订单相关产品
//        List<Product> orderProducts = new ArrayList<>();
//        for (Long productId : productIds) {
//            Product param = new Product();
//            param.setId(productId);
//            ApiResult<Product> result = productFeignClient.queryOne(param);
//            if (result.isSuccess() && result.getData() != null) {
//                orderProducts.add(result.getData());
//            }
//        }
//
//        int totalOrderProducts = orderProducts.size();
//        if (totalOrderProducts >= startIndex + size) {
//            // 如果订单产品数量足够，直接返回分页结果
//            List<Product> pageProducts = orderProducts.subList((int)startIndex, (int)(startIndex + size));
//            Page<Product> resultPage = new Page<>(current, size, totalOrderProducts);
//            resultPage.setRecords(pageProducts);
//            return resultPage;
//        }
//
//        // 计算还需要补充的产品数量
//        long needMore = startIndex + size - totalOrderProducts;
//
//        // 调用远程服务获取补充产品（排除已有的产品ID）
//        Product excludeParam = new Product();
//        excludeParam.setEnableFlag(true);
//
//        ApiResult<IPage<Product>> supplementResult = productFeignClient.list(1, (int)needMore, excludeParam);
//
//        List<Product> supplementProducts = new ArrayList<>();
//        if (supplementResult.isSuccess() && supplementResult.getData() != null) {
//            supplementProducts = supplementResult.getData().getRecords();
//
//            // 过滤掉已有的产品ID
//            supplementProducts = supplementProducts.stream()
//                    .filter(p -> !productIds.contains(p.getId()))
//                    .collect(Collectors.toList());
//
//            // 按价格降序排序
//            supplementProducts.sort(Comparator.comparingInt(Product::getPrice).reversed());
//        }
//
//        // 合并产品列表
//        List<Product> allProducts = new ArrayList<>(orderProducts);
//        allProducts.addAll(supplementProducts);
//
//        // 再次按价格降序排序
//        allProducts.sort(Comparator.comparingInt(Product::getPrice).reversed());
//
//        // 获取总产品数
//        Product countParam = new Product();
//        countParam.setEnableFlag(true);
//        ApiResult<IPage<Product>> countResult = productFeignClient.list(1, 1, countParam);
//        long total = countResult.isSuccess() ? countResult.getData().getTotal() : allProducts.size();
//
//        // 截取当前页数据
//        int endIndex = (int)Math.min(startIndex + size, allProducts.size());
//        List<Product> pageProducts = allProducts.subList((int)startIndex, endIndex);
//
//        // 创建分页结果
//        Page<Product> resultPage = new Page<>(current, size, total);
//        resultPage.setRecords(pageProducts);
//        return resultPage;
//    }
//
//    @Override
//    public IPage<Product> recommendProductListByOrder(Page<Product> page, Order order) {
//        Long productId = order.getProductId();
//        Product param = new Product();
//        param.setId(productId);
//        ApiResult<Product> apiResult = productFeignClient.queryOne(param);
//
//        Product product = apiResult.getData();
//        Integer price = product.getPrice();
//
//        int priceRange = (int) (price * 0.2);
//        int minPrice = price - priceRange;
//        int maxPrice = price + priceRange;
//
//        QueryWrapper<Product> queryWrapper = new QueryWrapper<>();
//        queryWrapper.between("price", minPrice, maxPrice);
//        queryWrapper.ne("id", productId);
//        queryWrapper.orderByAsc("ABS(price - " + price + ")");
//        // 执行分页查询
//        return recommendMapper.selectPage(page, queryWrapper);
//    }
}
